17 Umstieg auf Java (IntelliJ)

In diesem Kapitel steigen wir von Processing auf Java um. Außerdem lernen wir eine professionelle Entwicklungsumgebung (engl. IDE) kennen, IntelliJ IDEA (kurz: IntelliJ), die uns das Leben mittelfristig leichter machen wird.

Warum müssen wir überhaupt auf "Java" umsteigen. Ist Processing nicht Java? Processing ist eben nur fast Java. Processing verwendet eine Bibliothek von Zusatzfunktionen und einen mittelgroßen "Zaubertrick", um Ihnen das Leben zu erleichtern. Der Zaubertrick besteht darin, dass alle Ihre Programme in Wirklichkeit eine Unterklasse der Klasse PApplet sind. Wenn Sie in Java programmieren, stehen Ihnen einerseits einige Funktionen nicht mehr zur Verfügung und andererseits müssen Sie Dinge lernen wie "Wie starte ich mein Java-Programm?".

Wir wollen dieses Semester auch lernen, Android-Endgeräte zu programmieren. Warum? Weil man komplett in Java programmiert und das können wir ja schon (fast). Und warum Android und nicht iOS (Apple)? Android ist 2017 auf über 85% Marktanteil im mobilen Bereich, also bei Smartphones und Tablets, geklettert.

Damit uns der Umstieg auf Android leicht fällt, verwenden wir die Entwicklungsumgebung IntelliJ, denn die Entwicklungsumgebung für Android (Android Studio) basiert auf IntelliJ.

17.1 IntelliJ und Java

Eine "Integrierte Entwicklungsumgebung" (Integrated Development Environment, IDE) fasst verschiedene Dienste in ein einziges Programm mit einer schicken Oberfläche zusammen. Einige dieser Dienste sind:

• Code schreiben: einen Editor zur Verfügung stellen, Vervollständigungsvorschläge während des Tippens liefern (code completion), schnell durch den Code navigieren
• Code compilieren und starten: Code wird übersetzt, Programm wird gestartet, Konsolen-Ausgabe wird angezeigt, Programm kann jederzeit unterbrochen werden
• Code debuggen: den Code Zeile für Zeile durchlaufen und dabei den aktuellen Zustand von Variablen einsehen
• Code-Refactoring: Klassen, Methoden und Variablen umbenennen, wobei alle Vorkommen des fraglichen Konstrukts durch den neuen Namen ersetzt werden

IntelliJ ist nur eine von mehreren IDE, die man für Java verwenden kann. Ein guter Grund, IntelliJ zu wählen ist, dass Google IntelliJ als Grundlage für die Android-Entwicklungsumgebung Android Studio auserkoren hat (seit 2015).

Es gibt natürlich andere IDE. Die zwei bekanntesten sind NetBeans und Eclipse. Netbeans ist die "offizielle" IDE der Firma, die Java derzeit entwickelt: Oracle. Eclipse ist ähnlich verbreitet wie NetBeans und hat mehr den "independent"-Charakter und ist bekannt für seine unzähligen Plugins. NetBeans und Eclipse sind beide kostenlos.

Installation von Java

Um in Java programmieren zu können, benötigen Sie zunächst Java SE (SE für Standard Edition). Java liegt seit 2018 in Version 10 vor. Wenn dies bei Ihrem Rechner nicht bereits installiert ist, gehen Sie zur Java-Downloads-Seite und laden und installieren das JDK (Java Development Kit, nicht zu verwechseln mit JRE).

Außerdem empfehle ich Ihnen, die API-Dokumentation der Java-Klassen runterzuladen und in Ihrem Browser zu bookmarken. Dazu müssen Sie auf der Java-Downloads-Seite bei "Java SE 10 Documentation" (relativ weit unten) auf den Download-Button klicken. Um die API zu öffnen, klicken Sie auf die index.html Datei.

Noch ein technischer Hinweis: Verwenden Sie im Code niemals Umlaute (ä, ü, ö) oder das scharfe s (ß). Natürlich dürfen Sie Umlaute in Strings oder Kommentaren verwenden, aber nicht für Klassen-, Paket, Methoden- oder Variablennamen. Umlaute verursachen leider immer wieder Probleme.

Installation von IntelliJ

Dann installieren Sie IntelliJ. Laden Sie dazu die kostenlose Community Edition (CE) im Download-Bereich runter. Dann installieren Sie die Software und starten IntelliJ.

Projekt anlegen

Was in Processing ein "Sketch" (Skizze) ist, ist in IntelliJ ein Projekt. Ein Projekt wird genauso wie ein Sketch in einem eigenen Verzeichnis gespeichert. Wählen Sie im Hauptmenü File > New Project... und es erscheint ein Dialogfenster, das Sie durch den Prozess führt.

Als erstes müssen Sie IntelliJ sagen, wo Ihr Java ist. (Wenn bei Ihnen in der Zeile "Project SDK" bereits etwas mit "java" steht, können Sie diesen Punkt einfach mit "Next" überspringen.)

Auf einem Mac sieht das so aus.

Unter Windows liegt es irgendwo unter Programme > Java

Bei etwaigen Zwischenschritten drücken Sie einfach auf "Next", ohne irgendwelche Dinge zu markieren!

Jetzt geben Sie Ihrem Projekt einen Namen und verändern nach Bedarf das Verzeichnis, wo die IntelliJ-Projekte gespeichert werden sollen.

Geschafft! IntelliJ zeigt Ihnen die integrierte Oberfläche. Sie sehen zwei Teilfenster für den Code (rechts) und für das Projektverzeichnis (links).

In Java liegt jede Klasse in einer eigenen Datei mit der Endung .java (die Datei muss exakt so heißen wie die Klasse!). Im Projektverzeichnis sehen Sie ein Unterverzeichnis "src". Dort kommen alle Ihre Klassen hinein.

Legen Sie eine neue Klasse Foo an, indem Sie auf "src" einen Rechtsklick ausführen und New > Java Class wählen.

Die Klasse erscheint dann im Projektverzeichnis unter "src". Sie können jetzt im rechten Bereich den Code für die Klasse "Foo" schreiben:

Was der Code bedeutet, erfahren wir gleich...

Einstiegspunkt mit main

Ein wichtiger Unterschied zwischen Java und Processing ist: In Java besteht ein Programm nur aus Klassen, es gibt kein "Hauptprogramm" und kein setup() oder draw(). Wenn es kein Hauptprogramm gibt, stellt sich die Frage: Welcher Code wird ausgeführt, wenn wir unser Programm starten? Wo ist also der Einstiegspunkt, ab wo die Programmzeilen abgearbeitet werden?

Die Antwort lautet: Sie legen in einer Ihrer Klassen eine spezielle Methode an, die Java als Einstiegspunkt verwendet. Diese Methode heißt die statische main()-Methode. Sie muss zwingend den Rückgabetyp void haben und als Parameter einen String-Array. Nehmen wir an, Sie definieren diese Methode in der Klasse Foo. Dann können Sie Java anweisen, "die Klasse Foo zu starten". Java sucht in der Klasse nach der main()-Methode und, sofern diese vorhanden ist, wird diese ausgeführt.

Was bedeutet "statisch"? Statisch bedeutet in Java, dass eine Methode ausgeführt werden kann, obwohl kein Objekt der Klasse existiert. Normalerweise kann eine Methode nur auf einem Objekt ausgeführt werden. Stellen Sie sich eine Klasse "Person" mit der Methode "getFullName()" vor. Die Methode kann nur auf konkreten Objekten ausgeführt werden, nicht auf der Klasse. Die main()-Methode hingegen gehört zu keinem Objekt, sondern zur Klasse. Man nennt statische Methoden auch Klassenmethoden.

System.out.println

Wir wollen einfach einen String ausgeben, wenn wir MyClass starten. In Java gibt es leider kein einfaches "println" wie in Processing. Stattdessen schreiben Sie:

System.out.println("hello");

Die Bedeutung dieses Ausdrucks ist wie folgt: System ist eine Klasse, die Java von Haus aus zur Verfügung stellt. Das out ist eine Variable der Klasse System, allerdings eine statische Variable (siehe oben), weshalb man sie auch auf der Klasse aufrufen kann. Die Variable out enthält ein Objekt vom Typ PrintStream . PrintStream stellt die Befehle print und println zur Verfügung, wie Sie in der Java API nachlesen können.

Um Ihnen Schreibarbeit zu sparen, gibt es in modernen IDEs sogenannte Templates, das sind sehr häufig vorkommende Code-Teile, mit man mit den Anfangsbuchstaben der Wörter aktivieren kann. Bei IntelliJ heißt das Live Templates: mehr dazu finden Sie im der Dokumentation). Sie tippen eine Abkürzung ein, z.B. "sout" für "System.out.println"...

...Und drücken dann die Tabulator-Taste (oder ENTER). IntelliJ ersetzt die Abkürzung durch Code:

Jetzt schreiben wir den Text:

Programm starten

Und starten das Programm mit dem grünen Play-Button in der Toolbar.

Der Druck auf den Play-Button löst sowohl das Compilieren des Codes (Übersetzung in Maschinensprache, genauer: Bytecode) als auch das Starten des Codes (genauer: der main-Methode in MyClass) aus.

Im rechten unteren Teil erscheint jetzt auch die Konsole, die Sie auch aus Processing kennen.

Sie haben Ihr erstes Java-Programm geschrieben!

17.2 Klassen in Java

Wir nähern uns Java an, indem wir ein zweites Programm schreiben. Dazu legen wir ein Projekt "SecondTimeJava" an.

Pakete

Java bietet "packages" (Pakete) an, um Ihre Klassen besser zu organisieren. Pakete können wie Verzeichnisse verschachtelt werden. Es wird empfohlen, gleich zu Beginn ein Paket einzurichten. Wir nennen unseres "fancyproject". Beachten Sie, dass Paketnamen komplett in Kleinbuchstaben geschrieben werden.

Das neue Paket wird innerhalb von "Source Packages" gezeigt. Wenn Sie eine neue Klasse erstellen, markieren Sie das Paket und dann Rechtsklick:

Wir erstellen die Klasse Toy (Spielzeug). Sie sehen ganz oben im Code die Zeile

package fancyproject;

Damit wird angezeigt, dass die Klasse im Paket "fancyproject" liegt:

Unterpakete

Sie können Pakete und Unterpakete anlegen. Ein Unterpaket wird einfach mit einem Punkt an das übergeordnete angehängt.

Erstellen Sie ein zweites Paket, das aus zwei Unterpaketen besteht. Sie können beim Erstellen eines Pakets direkt eingeben:

de.hsa.toyproject

Erstellen Sie in dem Paket eine Klasse.

Sie sehen, dass im Code unter package der "Pfad" mit Punkten steht. Auf Ihrer Festplatte wird aber für jedes Unterpaket ein Unterverzeichnis angelegt. Das heißt die Datei Toy.java liegt unter

src/de/hsa/toyproject

Schauen Sie sich das Verzeichnis "src" und die entsprechenden Unterverzeichnisse am besten mal in Ihrem File-Explorer an.

Zugriffsmodifikatoren

Wir legen drei Instanzvariablen an:

public class Toy {

  private String bezeichnung;
  private int seriennummer;
  private double preis;
}

Ihnen werden die Begriffe public und private auffallen. Dies sind Zugriffsmodifikatoren (auch: Sichtbarkeitsmodifikatoren). Diese Begriffe geben an, wer auf diese Klasse bzw. die Variablen zugreifen kann.

Der Begriff public bedeutet: Jeder kann auf die Klasse/Variable zugreifen, insbesondere können andere Objekte darauf zugreifen. private heißt bei Variablen, dass nur ein Objekt dieser Klasse darauf zugreifen kann.

Es gibt noch einen weiteren Modifikator protected. Mit diesem Modifikator dürfen auch die Unterklassen auf die Variable zugreifen (und auch alle Klassen innerhalb des gleichen Pakets).

Die folgende Tabelle fasst zusammen, wer Zugriff auf eine(n) Klasse, Konstruktor, Methode oder Instanzvariable hat:

Sie sehen hier auch, was passiert, wenn Sie den Modifikator ganz weglassen ("leer"). Diesen Fall nennt man package-private. Hier haben die Unterklassen keinen Zugriff, dafür aber alle Klassen im selben Paket. Diese Kombination ist selten sinnvoll, daher sollten Sie immer einen Modifikator hinschreiben.

Jetzt wollen wir einen Konstruktor erstellen. IntelliJ bietet Ihnen hier eine Automatik an, die man mit Code > Generate... oder mit einer dort angegebenen Tastenkombination oder mit Rechtsklick (im Code) und Generate auslöst. Wählen Sie dann "Constructor...":

IntelliJ fragt Sie, welche der drei Instanzvariablen Sie als Parameter im Konstruktor haben möchten. Markieren Sie alle drei (Klicken zusammen mit SHIFT oder STRG bzw. CMD beim Mac). Dann auf OK.

IntelliJ produziert einen lehrbuch-mäßigen Konstruktor:

Getter- und Setter-Methoden

In Java spielt die Sichtbarkeit einer Variablen eine große Rolle. Die Faustregel für Instanzvariablen lautet: Im Zweifelsfall jede Instanzvariable als "private" deklarieren.

Private Variablen dürfen selbst von Unterklassen nicht angefasst werden. Wie manipuliert man dann die Variablen von außen? Zum Beispiel diese hier:

private String bezeichnung;

Ganz einfach: man definiert Methoden, um die Variablen zu manipulieren. Um den Wert zu erhalten, definiert man eine Getter-Methode, die natürlich "public" ist und somit von überall her aufrufbar.

public String getBezeichnung() {
  return bezeichnung;
}

Um den Wert zu verändern, definiert man eine Setter-Methode, die den neuen Wert als Parameter bekommt:

public void setBezeichung(String b) {
  bezeichnung = b;
}

IntelliJ nimmt uns das lästige Schreiben der immergleichen Getter- und Setter-Methoden ab. Wieder lösen wir das Generate... Menü aus. Diesmal nehmen wir "Getter and Setter..."

Im nächsten Schritt sagen Sie, welche Instanzvariablen genau Sie per Getter und Setter zugänglich machen wollen:

Schließlich sehen Sie den generierten Code, den Sie natürlich frei bearbeiten oder löschen können.

Statische main

Wir schreiben eine Klasse, um Toy-Objekte zu verwalten, inklusive dem Hinzufügen von Toy-Objekten und dem Ausdrucken aller Objekte.

package fancyproject;

import java.util.ArrayList;

/**
* @author Michael Kipp
*/
public class ToyAlbum {
  private ArrayList<Toy> toys;

  public ToyAlbum() {
    toys = new ArrayList<Toy>();
  }

  public void addToy(Toy toy) {
    toys.add(toy);
  }

  public void printToys() {
    for (Toy toy: toys) {
      System.out.println(toy);
    }
  }
}

Schließlich schreiben wir eine statische main-Methode. Nutzen Sie hier das nützliche Code-Template psvm für "public static void main(String[] args)":

public static void main(String[] args) {
  ToyAlbum album = new ToyAlbum();
  album.addToy(new Toy("Lonny", 25001, 29.95));
  album.addToy(new Toy("Donny", 25002, 31.95));
  album.addToy(new Toy("Bonny", 25003, 79.95));
  album.printToys();
}

In der main-Methode erzeugen wir ein ToyAlbum-Objekt und fügen einige Testobjekte hinzu. Anschließend drucken wir alle Objekte aus. Drücken Sie auf den Run-Button von IntelliJ.

Wir sehen die Objektausgaben. Um das ganze informativer zu gestalten, fügen wir in der Klasse Toy eine toString-Methode hinzu.

public String toString() {
  return bezeichnung + ", " + seriennummer + ", " +
  preis + " EUR";
}

Jetzt haben wir eine aussagekräftige Ausgabe:

Klassen importieren

Nehmen wir an, wir wollen eine Liste von Toy-Objekten speichern. Obwohl die Klasse ArrayList zur Java-Standardbibliothek gehört, kann sie nicht einfach verwendet werden, sondem muss importiert werden. Dies erfolgt durch den Befehl import, der noch oberhalb der Klasse stehen muss. Glücklicherweise unterstützt uns IntelliJ dabei.

Sie tippen Ihren Code und sehen die Fehlermeldung (rote Unterstreichung erscheint, dann Maus über die Glühbirne am linken Rand halten).

Drücken Sie STRG-ENTER, um das folgende Kontext-Menü zu erhalten, und wählen Sie Fix Imports. (Alternativ im Hauptmenü unter Source > Fix Imports...)

Sie sehen jetzt oberhalb der Klasse das "import java.util.ArrayList". Dies ist der vollständige Klassenname. Man sieht, dass die Klasse in einem Paket namens "java" und dort im Unterpaket "util" verortet ist. Pakete und Unterpakete werden mit Punkten getrennt.

Ein weiteres nützliches Feature ist code completion. Wenn Sie einen Befehl, einen Klassen- oder Variablennamen eintippen, können Sie jederzeit STRG-LEERTASTE drücken und IntelliJ macht Ihnen Vorschläge zur Vervollständigung.

17.3 Dokumentation

Verzeichnisstruktur

Wenn Sie in das Verzeichnis gehen, in dem ein IntelliJ-Projekt gespeichert ist, sehen Sie folgendes (nachdem Sie Ihr Programm mindestens einmal gestartet haben):

Das wichtigste Verzeichnis ist src, Kurzform für "source code" also Quellcode, das sind Ihre Klassendateien, die alle die Extension .java haben. Für jedes Paket, das Sie angelegt haben, gibt es ein Unterverzeichnis, d.h. Sie haben ein Unterverzeichnis "fancyprojects", in dem die Dateien "Toy.java" und "ToyAlbum.java" liegen.

Im Verzeichnis out werden die in Bytecode übersetzten Datein gespeichert Es gibt eine Verzeichnisstruktur, die analog zum Quellcode ist, nur dass jede Klassendatei mit .class endet. (In anderen Tools heißt dieses Verzeichnis oft "build".)

Die Datei mit der Endung .iml enthält Einstellungsinfos zu Ihrem Projekt.

Kommentare und Javadoc

In Java können Kommentare so verwendet werden, dass eine umfassende Code-Dokumentation in Form von Webseiten daraus generiert werden kann. So ist zum Beispiel die Dokumentation der Java-Standardbibliothek genau so entstanden.

Das Tool, das die Kommentare in eine HTML-Dokumentation umwandelt, heißt Javadoc. Es werden nicht alle Kommentare für diese Dokumentation verwendet, sondern nur solche, die direkt vor einer Klasse, Instanzvariable, Konstruktor oder Methode stehen und die so aussehen:

/**
 * Dies ist meine erste Klasse.
 *
 * @author Lisa Schmidt
 */

public class MyClass {
  ...
}

Ausschlaggebend ist das doppelte Sternchen zu Beginn. Das signalisiert Javadoc, dass der Kommentar in die Dokumentation soll. Der Spezialschlüssel "@author" erlaubt es, den Autoren der Klasse einzufügen. Solche Informationen werden an bestimmte Stellen in der HTML-Doku platziert.

Bei einer Methode sieht das so aus:

/**
 * Berechnet Summe.
 *
 * @param a erster Summand
 * @param b zweiter Summand
 * @return Summe von a und b
 */

public int computeSum(int a, int b) {
  return a + b;
}

Die Schlüsselwörter @param und @return sind Erweiterungen des Kommentars, die es Javadoc erlauben, eine differenziertere Dokumentation zu erstellen.

Sie können Javadoc auf Ihrem eigenen Projekt ausführen mit Tools > Generate JavaDoc. Sie müssen dann noch unter "Output directory" das Verzeichnis angeben, wo die entsprechenden Dokumentationsseiten (HTML) angelegt werden sollen. Ein guter Ort wäre ein Unterverzeichnis namens doc, das Sie in Ihrem Projektverzeichnis erzeugen müssen.

Javadoc erzeugt mehrere HTML-Dateien, die anschließend von IntelliJ geöffnet werden. Die Dateien sind in dem Unterverzeichnis zu finden, das Sie angegeben/angelegt haben.

Java-Dokumentation verwenden

Die Entwicklung der Sprache ist insofern faszinierend, als dass große Teile der Sprache in Java selbst geschrieben sind. Die Entwickler von Java haben Klassen wir String oder ArrayList geschrieben und der Sprache hinzugefügt. Eine Ansammlung von Klassen nennt man auch Bibliothek (engl. library). Die Klassen, die fest zur Sprache Java gehören, nennt man die Java-Standardbibliothek.

Die Java-Entwickler haben das oben beschriebene Javadoc verwendet, um die Standardbibliothek zu dokumentieren. Bei der Programmierung in Java greift man ständig auf diese Dokumentation zurück.

Sie können jederzeit im Internet aktuelle Java-Dokumentation finden. Noch besser ist es, sich die Dokumentation von der Java-Downloads-Seite runterzuladen und im Browser zu bookmarken, damit Sie auch offline darauf zugreifen können.

Auf der Startseite sehen Sie alle Pakete (links oben) und alle Klassen (links unten):

Wenn Sie eine bestimmte Klasse - z.B. ArrayList suchen, verwenden Sie am besten die Suchfunktion des Browsers (STRG-F oder CMD-F). Der Browser sucht dann u.a. in der Klassenliste (links unten). Haben Sie die Klasse gefunden, klicken Sie darauf und Sie gelangen auf eine neue Seite mit der Klassenbeschreibung.

In der Klassenbeschreibung sehen Sie, zu welchem Paket die Klasse gehört, welche Konstruktoren, welche Methoden sie hat und vieles mehr.

Weiter unten auf der Seite finden Sie die Methoden, die natürlich besonders interessant sind.

Über einen Klick gelangen Sie nochmals zu einer detaillierteren Beschreibung der Methode.

Refactoring

Ein "Killer-Feature" von IDEs wie IntelliJ ist die Möglichkeit, die Namen von Klassen, Variablen und Methoden über Ihr gesamtes Projekt hinweg umzubenennen, ohne dass Sie jede Stelle suchen müssen, wo dieser Name auftaucht. Eine solche Aktion läuft unter dem Begriff Refactoring (wobei Refactoring allgemein bedeutet, den Code so umzubauen, dass er robuster und leichter lesbar wird).

Nehmen wir an, Sie möchten die Klasse "Toy" in "Spielzeug" umbenennen. Der Begriff Toy taucht an vielen Stellen auf, z.B. bei "ArrayList<Toy>". Mit Rechtklick auf den Klassennamen (egal, wo er auftaucht), bekommen Sie ein Kontextmenü, in dem Sie Refactor > Rename wählen (Sehen Sie sich auch den Tastaturkürzel an, variiert nach Betriebssystem):

In einfachen Fällen editieren Sie direkt im Code, in komplexeren Fällen, wie bereits hier bei Toy, erscheint ein Dialog, der nach dem neuen Namen fragt.

Nach einem Druck auf Refactor, werden alle Vorkommen des Namens ersetzt.

Double statt float

In Processing sind wir es gewohnt, für Gleitkommmazahlen Variablen vom Typ float anzulegen. In Java ist es Konvention, den Typ double zu verwenden, also den Datentyp, der doppelte Präzision zulässt, dafür aber auch doppelt soviel Speicher benötigt (8 Byte statt 4 Byte).

Gewöhnen Sie sich also besser an, immer double zu verwenden, denn alle Klasse aus Bibliotheken verwenden es und sonst müssen Sie ständig die Zahlen vom Typ double auf float casten.

In Java wird double als Standardtyp für Gleitkommazahlen verwendet. Versuchen Sie, sich schnell umzugewöhnen und immer double zu verwenden!

NameGenerator gen = new NameGenerator();

gen.addVorname("Harry");
gen.addVorname("Sally");
gen.addVorname("Brad");
gen.addVorname("Angie");
gen.addVorname("Barack");

gen.addNachname("Miller");
gen.addNachname("Merkel");
gen.addNachname("Obama");
gen.addNachname("Putin");
gen.addNachname("Sanders");

for (int i = 0; i < 5; i++) {
  System.out.println(gen.createName());
}

Scanner scanner = new Scanner(System.in);
String input = "";
while (!input.equals("q")) {
    input = scanner.nextLine(); // User Input
    System.out.println("Ihre Eingabe: " + input); // nur zum Testen
}
scanner.close();

Frage: Wie heißt der US-Präsident?
[0] Dampf
[1] Trump
[2] Trumpf
[3] Tram
1
R I C H T I G

Frage: Autor von Emilia Galotti?
[0] Schiller
[1] Kleist
[2] Goethe
[3] Lessing
0
Leider falsch. Richtig ist: Lessing

Frage: Wo findet Olympia 2022 statt?
[0] Tokio
[1] Peking
[2] L.A.
[3] Hamburg
1
Leider falsch. Richtig ist: Tokio

Sie haben 0 von 3 Fragen richtig beantwortet.

17.4 Java durchleuchtet

Hier finden Sie zwei Videos, die beleuchten, was der Unterschied zwischen Ihrem Quellcode und dem ausführbaren Programm ist. Sie sehen ferner, wie Sie auf einer "Command Shell" (auch Konsole genannt) Ihren Code compilieren und ausführen können.

17.5 Literatur

• Schauen Sie in mein Java-Notbuch, wo die wichtigsten Konzepte übersichtlich in einem PDF dargestellt sind
• Eines der meist genutzten Bücher zu Java ist nicht nur online verfügbar, sondern auch kostenlos: Java ist auch eine Insel von Christian Ullenboom
• Die ultimative Quelle für weiterführendes Verständnis (dabei sehr lesbar), sind die Core Java Bücher von Cay Horstmann.
• Java-Tutorial-Seite zu Zugriffsmodifikatoren (Oracle)